
// pages/index/index.js
const { todoManager, tagManager } = require('../../utils/cloud')
const { formatDateTime, compareDateTime } = require('../../utils/dateHelper')
const { toast, dialog, nav, errorHandler } = require('../../utils/uiHelper')

const app = getApp()

Page({
  data: {
    todos: [],
    isLogin: false,
    filterType: 'all', // all, pending, completed
    selectedTags: [],
    availableTags: [],
    searchKeyword: '',
    sortType: 'time', // time, status
    isLoading: false
  },

  onLoad: async function() {
    // 检查登录状态
    const isLogin = app.globalData.isLogin
    this.setData({ isLogin })
    
    if (isLogin) {
      await this.loadInitialData()
    }
  },

  onShow: async function() {
    if (this.data.isLogin) {
      await this.loadTodos()
    }
  },

  // 下拉刷新
  onPullDownRefresh: async function() {
    if (this.data.isLogin) {
      await this.loadTodos()
    }
    wx.stopPullDownRefresh()
  },

  // 加载初始数据
  async loadInitialData() {
    try {
      toast.loading('加载中...')
      await Promise.all([
        this.loadTodos(),
        this.loadTags()
      ])
    } catch (err) {
      errorHandler.handle(err, '加载失败')
    } finally {
      toast.hideLoading()
    }
  },

  // 加载待办事项列表
  async loadTodos() {
    try {
      this.setData({ isLoading: true })
      
      const result = await todoManager.listTodos({
        status: this.data.filterType === 'all' ? undefined : 
               this.data.filterType === 'completed'
      })

      if (result.code === 0) {
        // 处理待办事项数据
        const todos = result.data.map(todo => ({
          ...todo,
          displayTime: formatDateTime.friendly(todo.reminderTime),
          isOverdue: !todo.status && compareDateTime.isBeforeNow(todo.reminderTime)
        }))

        // 应用筛选和排序
        const filteredTodos = this.filterAndSortTodos(todos)
        
        this.setData({ todos: filteredTodos })
      } else {
        throw new Error(result.msg)
      }
    } catch (err) {
      errorHandler.handle(err, '加载待办事项失败')
    } finally {
      this.setData({ isLoading: false })
    }
  },

  // 加载标签列表
  async loadTags() {
    try {
      // 先设置一些默认标签，确保UI可以显示
      const defaultTags = [
        { name: '工作', color: '#4A90E2' },
        { name: '生活', color: '#50B347' },
        { name: '学习', color: '#E6A23C' },
        { name: '重要', color: '#F56C6C' },
        { name: '紧急', color: '#FF5722' }
      ];
      
      console.log('设置默认标签:', defaultTags);
      
      // 先设置默认标签，确保UI立即有内容显示
      this.setData({ 
        availableTags: defaultTags 
      }, () => {
        console.log('默认标签设置完成，当前标签列表:', this.data.availableTags);
      });
      
      // 然后尝试从云端加载
      try {
        console.log('开始从云端加载标签...');
        const result = await tagManager.listTags();
        console.log('云端标签加载结果:', result);
        
        if (result && result.code === 0) {
          // 如果没有标签，初始化默认标签
          if (!result.data || result.data.length === 0) {
            console.log('云端没有标签，开始初始化默认标签...');
            try {
              const initResult = await tagManager.initDefaultTags();
              console.log('初始化默认标签结果:', initResult);
              
              if (initResult && initResult.code === 0 && initResult.data) {
                this.setData({ 
                  availableTags: initResult.data 
                }, () => {
                  console.log('云端默认标签设置完成，当前标签列表:', this.data.availableTags);
                });
              }
            } catch (initErr) {
              console.error('初始化默认标签失败:', initErr);
              // 保持使用默认标签
            }
          } else {
            this.setData({ 
              availableTags: result.data 
            }, () => {
              console.log('云端标签设置完成，当前标签列表:', this.data.availableTags);
            });
          }
        }
      } catch (cloudErr) {
        console.error('从云端加载标签失败:', cloudErr);
        // 保持使用默认标签
      }
    } catch (err) {
      console.error('加载标签失败:', err);
      // 不显示错误提示，因为我们已经有默认标签
    }
  },

  // 筛选和排序待办事项
  filterAndSortTodos(todos) {
    let filteredTodos = [...todos]
    
    // 根据标签筛选
    if (this.data.selectedTags.length > 0) {
      filteredTodos = filteredTodos.filter(todo => {
        // 确保todo.tags存在且是数组
        const todoTags = Array.isArray(todo.tags) ? todo.tags : []
        // 满足任一选中标签即可（OR关系）
        return this.data.selectedTags.some(selectedTag => 
          todoTags.includes(selectedTag)
        )
      })
    }

    // 根据关键词搜索
    if (this.data.searchKeyword) {
      const keyword = this.data.searchKeyword.toLowerCase()
      filteredTodos = filteredTodos.filter(todo => 
        todo.title.toLowerCase().includes(keyword) || 
        (todo.content && todo.content.toLowerCase().includes(keyword))
      )
    }

    // 排序
    filteredTodos.sort((a, b) => {
      if (this.data.sortType === 'time') {
        return new Date(b.reminderTime) - new Date(a.reminderTime)
      } else {
        // 按状态排序：未完成在前，相同状态按时间倒序
        if (a.status === b.status) {
          return new Date(b.reminderTime) - new Date(a.reminderTime)
        }
        return a.status ? 1 : -1
      }
    })

    // 更新筛选结果状态
    const hasResults = filteredTodos.length > 0
    if (!hasResults && (this.data.selectedTags.length > 0 || this.data.searchKeyword)) {
      // 如果有筛选条件但没有结果，显示提示
      wx.showToast({
        title: '没有符合条件的待办事项',
        icon: 'none',
        duration: 2000
      })
    }

    return filteredTodos
  },

  // 切换筛选类型
  async onFilterChange(e) {
    const type = e.currentTarget.dataset.type
    this.setData({ filterType: type })
    await this.loadTodos()
  },

  // 切换排序方式
  async onSortChange(e) {
    const type = e.currentTarget.dataset.type
    this.setData({ sortType: type })
    await this.loadTodos()
  },

  // 标签选择
  onTagSelect: function(e) {
    try {
      console.log('标签选择 - 事件数据:', e);
      const tag = e.currentTarget.dataset.tag;
      console.log('标签选择 - 选中标签:', tag);
      
      if (!tag) {
        console.error('标签选择 - 未获取到标签名称');
        return;
      }
      
      // 复制当前已选标签数组，避免直接修改
      const selectedTags = [...this.data.selectedTags];
      const index = selectedTags.indexOf(tag);
      
      console.log('标签选择 - 当前已选标签:', selectedTags);
      console.log('标签选择 - 标签索引:', index);

      if (index === -1) {
        // 添加标签
        selectedTags.push(tag);
        console.log('标签选择 - 添加标签后:', selectedTags);
        
        // 找到对应的标签颜色
        const tagObj = this.data.availableTags.find(t => t.name === tag);
        if (tagObj) {
          try {
            wx.vibrateShort({ type: 'light' }); // 轻微震动反馈
          } catch (e) {
            console.log('震动反馈不支持:', e);
          }
        }
      } else {
        // 移除标签
        selectedTags.splice(index, 1);
        console.log('标签选择 - 移除标签后:', selectedTags);
      }

      // 更新状态并重新加载数据
      this.setData({ selectedTags }, () => {
        console.log('标签选择 - 更新后的已选标签:', this.data.selectedTags);
        
        // 重新筛选数据
        this.loadTodos();
      });
    } catch (err) {
      console.error('标签选择处理出错:', err);
      errorHandler.handle(err, '标签选择失败');
    }
  },

  // 清除所有已选标签
  clearSelectedTags: function() {
    console.log('清除所有标签');
    if (this.data.selectedTags.length === 0) return;
    
    try {
      wx.vibrateShort({ type: 'light' }); // 轻微震动反馈
    } catch (e) {
      console.log('震动反馈不支持:', e);
    }
    
    this.setData({ selectedTags: [] }, () => {
      this.loadTodos();
      toast.success('已清除所有筛选');
    });
  },

  // 搜索输入
  onSearchInput: function(e) {
    this.setData({
      searchKeyword: e.detail.value
    });
    
    // 使用节流函数延迟加载
    if (this.searchTimer) {
      clearTimeout(this.searchTimer);
    }
    
    this.searchTimer = setTimeout(() => {
      this.loadTodos();
    }, 500);
  },

  // 手动刷新
  manualRefresh: function () {
          this.onLoad();
          wx.showToast({
              title: '刷新成功',
              icon: 'success'
          });
      },

      // 切换待办事项状态
      async toggleTodoStatus(e) {
              try {
      const id = e.currentTarget.dataset.id
      const result = await todoManager.toggleTodoStatus(id)
      
      if (result.code === 0) {
        // 更新本地数据
        const todos = this.data.todos.map(todo => {
          if (todo._id === id) {
            return { ...todo, status: result.data.status }
          }
          return todo
        })
        this.setData({ todos })
        toast.success('状态已更新')
      } else {
        throw new Error(result.msg)
      }
    } catch (err) {
      errorHandler.handle(err, '更新状态失败')
    }
  },

  // 删除待办事项
  async deleteTodo(e) {
    try {
      const id = e.currentTarget.dataset.id
      const confirmed = await dialog.confirm('确定要删除这个待办事项吗？')
      
      if (confirmed) {
        const result = await todoManager.deleteTodo(id)
        
        if (result.code === 0) {
          const todos = this.data.todos.filter(todo => todo._id !== id)
          this.setData({ todos })
          toast.success('删除成功')
        } else {
          throw new Error(result.msg)
        }
      }
    } catch (err) {
      errorHandler.handle(err, '删除失败')
    }
  },

  // 跳转到编辑页面
  navigateToEdit(e) {
    const id = e.currentTarget.dataset.id
    nav.to(`/pages/edit/index?id=${id}`)
  },

  // 跳转到添加页面
  navigateToAdd() {
    if (!app.checkLogin()) return
    nav.to('/pages/edit/index')
  }
})